AVR652.c

Go to the documentation of this file.

#include <avr/io.h>
#include <stdlib.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/eeprom.h>

// CONSTANTS
 
#define KEY_A     0x10              // switch on PB4
#define KEY_B     0x20              // switch on PB5
#define KEY_MODE  0x04              // swithc on PB2

#define TRUE      1
#define FALSE     0

#define GAUGE_MAX 0x4C
#define GAUGE_MIN 0x24

// GLOBAL VARIABLES

unsigned char speed = 16;

unsigned int EEMEM intensity[12] = {16, 16, 16, 32, 32, 32, 32, 32, 32, 32, 32, 32};
unsigned int EEMEM user_speed = 12;
unsigned int EEMEM torch_status = 17;

unsigned char keybuffer[8] = {0, 0, 0, 0, 0, 0, 0, 0};
unsigned char keybuffer_index = 0;

//  index |  0  |  1  |  2  |  3 |   4  |  5  |  6  |  7  |  8  |  9  |  10 |  11
//  ------+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----
//  I/O   | PA0 | PA1 | PA2 | PA3 | PA4 | PA5 | PA6 | PB0 | PB3 | PB6 | PB7 | PB1

volatile unsigned char LED[12] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
unsigned char led_pwm = 0;


//  Looks for a Valid Keypress
// Note: all switches must be connected to same port

unsigned char pressed(unsigned char key)
{
unsigned char i, sum;
        sum = key;
        for(i=0; i<8; i++)
        {
                sum &= keybuffer[i];
        }
        if(sum > 0)
                return(TRUE);
        else
                return(FALSE);
}

//  LED layout:
//  --------------------------
//  10      09      08      07
//  06  05  04  03  02  01  00
//  09      10      07      08
//  --------------------------
//  
//  eyes     |   1   |   2   |   3   |   4   |    5   |     6    |
//  ---------+-------+-------+-------+-------+--------+----------+
//           | .   . | .   * | .   * | *   * |  *   * |   *   *  |
//  pattern  | . * . | . . . | . * . | . . . |  . * . |   * . *  |
//           | .   . | *   . | *   . | *   * |  *   * |   *   *  |
//  ---------+-------+-------+-------+-------+--------+----------+
//  leds 1   | 1     | 7     | 1,7   | 7,8   | 1,7,8  | 0,2,7,8  |
//  leds 2   | 5     | 9     | 5,9   | 9,10  | 5,9,10 | 4,6,9,10 |


void  showDice(unsigned char dice, unsigned char eyes, unsigned char strength)
{
const unsigned int  pat[2][6] = { {0x0002, 0x0080, 0x0082, 0x0180, 0x0182, 0x0185},
                                    {0x0020, 0x0200, 0x0220, 0x0a00, 0x0a20, 0x0650} };
unsigned int  j, m;

        m=pat[dice][eyes];
        for(j=0; j<11; j++)
        {
                if(m & 0x01) 
                        LED[j] = eeprom_read_word(&intensity[j]);
                else
                        LED[j] = 0;
                m=m>>1;
        }
        LED[11]=0;
        _delay_us(500);
}

//  Do nothing -- go into Idle mode

void  idle(void)

{
unsigned char i;

        for(i=0; i<12; i++)
                LED[i]=eeprom_read_word(&intensity[i]);//Get stored intensity level from EEPROM
        _delay_us(100);
        for(i=0; i<12; i++)
                LED[i] = 0;
        PRR=0x01;
        MCUCR |=(1<<SE);
        asm("SLEEP");
        PRR=0x00;
        while (!pressed(KEY_MODE))
        {
                // wait for key to be released
        }
        _delay_us(100);
}

//  torch mode - Increase and Decrease intensity of High Brightness LED

void  torch(void)
{
unsigned char strength = 17;

        strength =  eeprom_read_word(&torch_status); //Retrive Previous Intensity level from EEPROM
        
        while(!pressed(KEY_MODE))
        {
                if(pressed(KEY_A))              //Increase intensity when KEY_A is pressed
                {
                        if(strength < 32)
                                strength += 1;
                }
                LED[11] = strength;
                _delay_us(100);
                
                if(pressed(KEY_B))              //Decrease intensity when KEY_B is pressed
                {
                        if (strength > 4)
                                strength -= 1;
                }
                LED[11] = strength;
                _delay_us(100);
        }
        eeprom_write_word(&torch_status,strength); //Store Intensity level in EEPROM
}


// Calculate the Number of LEDS to be lit for the present battery voltage level

void  set_gauge(unsigned char level)
{
unsigned char i,tip;
unsigned char rest;

        if(level > GAUGE_MIN)
        {
                rest =GAUGE_MAX - level;
                tip = rest /7;
                for(i=0;i<=7;i++)
                {
                        if(i < tip)
                                LED[7-i] = 0;
                        else if(i > tip)
                                        LED[7-i]=eeprom_read_word(&intensity[7-i]);    
                }
        }
        else 
                if(level < GAUGE_MIN)
                {
                        tip=0;
                        for(i=0;i<=7;i++) 
                                LED[i]=0;
                }
                else if(level > GAUGE_MAX)
                        {
                                for(i=0;i<=7;i++)  
                                        LED[i] = eeprom_read_word(&intensity[i]);       
                        }
}

//  Show battery voltage as LED bar

void  battery_gauge(void)

{
        ADMUX = 0x06;                     // read VBAT, reference to VCC
        ADCSRB = (1<<ADLAR);              // left-adjust result
        ADCSRA = (1<<ADEN) | (1<<ADSC);   // enable ADC & start single conversion
        
        while(!pressed(KEY_MODE))
        {
                ADCSRA = (1<<ADEN) | (1<<ADSC);   // enable ADC & start single conversion
                while(ADCSRA & (1<<ADSC));      
                set_gauge(ADCH);
                _delay_us(100);
        }
}

//  Placeholder for dice game mode

void  dice_game(void)
{ 
unsigned int five_5=0x07A2;
unsigned char i=0;

        for(i=0;i<11;i++)
        {
                if(five_5 &0x01)  
                        LED[i]=eeprom_read_word(&intensity[i]);
                else
                        LED[i]=0;
                five_5=five_5>>1;
        }
        _delay_us(10);

        while(!pressed(KEY_MODE))
        {
                if(pressed(KEY_A))
                {
                        showDice(1, (rand() % 6),32);
                }
                else if(pressed(KEY_B))
                         {
                                showDice(0,(rand() % 6),32);
                         }
                i++;
                if(i>7) i=0;
                _delay_us(100);
        }
}

//  Rolling LED pattern with fade

void  ritari_assa(void)
{
unsigned char i = 0;
signed char act = 1, dir = 0;
unsigned char disp[6] = {0, 0, 0, 0, 0, 0};
unsigned char strength[6] = {32, 16, 8, 1, 0, 0};

        speed =eeprom_read_word(&user_speed); //Get default speed from EEPROM

        while(!pressed(KEY_MODE))
        {   
                for(i=0;i<5;i++)
                        disp[5-i] = disp[4-i];
                disp[0] = act;
                for(i=0;i<5;i++)
                        LED[disp[5-i]] = strength[5-i];
                if(dir == 0)
                {
                        if(++act > 5)
                                dir = -1;
                }
                else
                {
                        if(--act < 0)
                                dir = 0;
                }
                
                if(pressed(KEY_A))      //Increase Speed at KEY_A
                {
                        if (speed < 128)
                                speed = (speed << 1);
                }
                _delay_us(100);
                
                if(pressed(KEY_B))              //Decrease Speed at KEY_B
                {
                        if (speed > 4)
                                speed = (speed >> 1);
                }
                _delay_us(100);
                
                for(i=0; i<speed; i++)
                        _delay_us(100);
        }
}

//  Blinking LED pattern with fade

void  twinkle(void)
{
unsigned char i, j = 2;

        speed =eeprom_read_word(&user_speed);
        srand(TCNT1);                 // seed value for random number generator
        while(!pressed(KEY_MODE))
        {
                for(i=0; i<12; i++)
                        LED[i] = (LED[i] >> 1);
                if(--j == 0)
                {
                        j = rand() % 11;
                        if(LED[j] == 0)
                                LED[j] = 32;
                        j = (rand() >> 12) + 1;
                }
        }
}

// Intialise Timer and Port values

void  initialise(void)
{
        TCCR1A = 0x00;                // no waveform generation, normal t/c
        TCCR1B = 0x01;                // no waveform generation, clk/1
        OCR1A = 0x00;
        OCR1B = 0x00;
        TIMSK1 = (1<< TOIE1);         // t/c overflow interrupt enable
        DDRA = 0x7f;                  // PA0...6 outputs
        DDRB = 0xcb;                  // PB0,1,3,6,7 outputs
        sei();
}


int  main( void )
{
unsigned char i;
unsigned char mode = 0;

        initialise();
        while(1)
        {
                for(i=0;i<12;i++)
                        LED[i] = 0;
                while(pressed(KEY_MODE))
                {
                        // wait for key to be released
                }
                switch(mode++)
                {
                        case 0: 
                                        idle();
                                        break;
                        case 1: 
                                        torch();
                                        break;
                        case 2: 
                                        battery_gauge();
                                        break;
                        case 3: 
                                        dice_game();
                                        break;
                        case 4: 
                                        ritari_assa();
                                        break;
                        case 5: 
                                        twinkle();
                                        break;
                }
                if(mode > 5)
                        mode = 0;
        }
}

// FUNCTIONS

//  Turn on a single LED. Called from ISR, only. LED layout:
//  --------------------------
//  10      09      08      07
//  06  05  04  03  02  01  00
//  09      10      07      08
//  --------------------------

void  setLED(unsigned char led)

{
        switch(led)
        {
        case 0:         
                                PORTA = PINA & 0xfe;  // xxxxxxx0
                    break;
                case 1: 
                                PORTA = PINA & 0xfd;  // xxxxxx0x
                break;
        case 2: 
                                PORTA = PINA & 0xfb;  // xxxxx0xx
                break;
        case 3: 
                                PORTA = PINA & 0xf7;  // xxxx0xxx
                break;
        case 4: 
                                PORTA = PINA & 0xef;  // xxx0xxxx
                break;
        case 5: 
                                PORTA = PINA & 0xdf;  // xx0xxxxx
                break;
        case 6: 
                                PORTA = PINA & 0xbf;  // x0xxxxxx
                break;
        case 7: 
                                PORTB = PINB & 0xfe;  // xxxxxxx0
                break;
        case 8: 
                                PORTB = PINB & 0xf7;  // xxxx0xxx
                break;
        case 9: 
                                PORTB = PINB & 0xbf;  // x0xxxxxx
                break;
        case 10:
                                PORTB = PINB & 0x7f;  // 0xxxxxxx
                break;
        case 11:
                                PORTB = PINB & 0xfd;  // xxxxxx0x
                break;
        }
}

//  Turn off a single LED. Called from ISR, only.

void  clearLED(unsigned char led)
{
        switch(led)
        {
                case 0:
                                PORTA = PINA | 0x01;  // xxxxxxx1
                                break;
        case 1: 
                                PORTA = PINA | 0x02;  // xxxxxx1x
                break;
        case 2: 
                                PORTA = PINA | 0x04;  // xxxxx1xx
                break;
        case 3: 
                                PORTA = PINA | 0x08;  // xxxx1xxx
                break;
        case 4: 
                                PORTA = PINA | 0x10;  // xxx1xxxx
                break;
        case 5: 
                                PORTA = PINA | 0x20;  // xx1xxxxx
                break;
        case 6: 
                                PORTA = PINA | 0x40;  // x1xxxxxx
                break;
        case 7: 
                                PORTB = PINB | 0x01;  // xxxxxxx1
                break;
        case 8: 
                                PORTB = PINB | 0x08;  // xxxx1xxx
                break;
        case 9: 
                                PORTB = PINB | 0x40;  // x1xxxxxx
                break;
        case 10:
                                PORTB = PINB | 0x80;  // 1xxxxxxx
                break;
        case 11:
                                PORTB = PINB | 0x02;  // xxxxxx1x
                break;
        }
}


// ISRs -- INTERRUPT SERVICE ROUTINES

// Timer/counter overflow interrupt handler
// Scan inputs and toggle LEDs according to intensity settings in LED[] array

ISR(TIM1_OVF_vect)
{
unsigned char i;

        // scan switches, store results in buffer for debouncing
        keybuffer[keybuffer_index++] = ~PINB;   // switches are logically inverted

        if(keybuffer_index > 7)
        keybuffer_index = 0;

        if(led_pwm == 0)
        {
        for(i=0;i<12;i++)
        {
                        if(LED[i] > 0)
                        setLED(i);
                else
                        clearLED(i);
                }
        }
        else
        {
                for(i=0;i<12;i++)
                {
                        if(LED[i] == led_pwm)
                                clearLED(i);
                }
        }

        if(++led_pwm > 31)  
                led_pwm = 0;
}